import uniIcons from '@dcloudio/uni-ui/lib/uni-icons/uni-icons.vue';
// 导入请求工具和函数
import { getFullImageUrl,initBaseUrl,request } from '../../utils/request';
import { reverseGeocoder } from '@/utils/mapUtils';
import { initWebSocket } from '@/utils/websocket';

import Header from '@/components/common/Header.vue';
import authWin from '@/components/authWin/authWin.vue';
import SuccessWindow from '@/components/common/successWindow/successWindow.vue';
import OrderSuccessModal from '@/components/common/OrderSuccessModal.vue';
import { wechatLogin, checkLogin } from '@/utils/authUtils';
export default {
  components: {
    uniIcons,
    Header,
    authWin,
    SuccessWindow,
    OrderSuccessModal
  },

  data() {
    return {
      // 基础数据
      latitude: 0,
      longitude: 0,
      localAddress: '磨碟沙花苑',
      selectedRegion: {},
      hasLoadedLocation: false, // 标记是否已经加载过当前定位
      
      // Banner数据
      bannerData: [],
      
      // 筛选数据
      activeMenu: '',
      // 当前选中的筛选类型和值
      currentFilter: {
        type: 'time', // 默认选中时间类型
        value: 'latest' // 默认选中最新发布
      },
      
      // 订单数据
      jobs: [],
      isLoading: false,
      hasMore: true,
      showApplySuccess: false,
      
      // 分页参数
      pageParams: {
        page: 1,
        limit: 10
      },
      
      // 分类数据
      categories: [],
      selectedCategory: null,
      
      // 用户信息
      auth: false,
      successContent: '报名成功，等待雇主确认',
      
      // 抢单成功相关
      successOrderData: {},
      showSuccessModal: false
    };
  },
  onLoad( options ) {
    // 从页面参数获取scene并存储
    if (options && options.scene) {
      const scene = decodeURIComponent(options.scene);
      uni.setStorageSync('scene', scene);
    }
    // 初始化基础URL
    initBaseUrl();
    // 页面加载时获取分类数据
    this.fetchCategories();
    // 获取Banner数据
    this.fetchBanner();

    // 页面加载时立即获取当前定位并显示
    this.getLocation().then(() => {
      this.fetchJobs();
    });
    wechatLogin();
    
    // 初始化WebSocket
    initWebSocket();
    // 注册全局WebSocket消息监听
    uni.$on('websocket-message', this.handleWebSocketMessage);
  },
  
  onUnload() {
    // 移除全局事件监听
    uni.$off('websocket-message', this.handleWebSocketMessage);
  },

  created() {
    // 监听位置更新事件
    this.locationUpdatedHandler = this.updateLocation.bind(this);
    this.$bus.$on('locationUpdated', this.locationUpdatedHandler);
  },

  destroyed() {
    // 移除事件监听
    this.$bus.$off('locationUpdated', this.locationUpdatedHandler);
  },
  onShow() {
    // 检查是否登录，如果登录则检查实名认证状态（仅在登录后首次进入首页时检查）
    if (checkLogin()) {
      this.checkAuthStatus();
    }

    // 从本地存储获取已选地区
    const lastSelectedRegion = uni.getStorageSync('selectedRegion') || {};

    // 只有在已经加载过定位后，才检查是否需要更新地区
    if (this.hasLoadedLocation && lastSelectedRegion.city) {
      // 简化比较，只比较city和district
      const isSameRegion =
        lastSelectedRegion.city === this.selectedRegion.city &&
        lastSelectedRegion.district === this.selectedRegion.district;

      if (!isSameRegion) {
        this.selectedRegion = lastSelectedRegion;
        console.log('地区发生变化，更新地址和订单数据');
        // 直接使用存储的地区信息，不需要重新获取经纬度
        this.localAddress = `${lastSelectedRegion.city}${lastSelectedRegion.district ? lastSelectedRegion.district : ''}`;
        // 重置分页参数
        this.pageParams.page = 1;
        this.hasMore = true;
        // 重新获取订单数据
        this.fetchJobs();
      }
    }
  },
  computed: {
    distanceText() {
      return this.distanceFilter === 'nearest' ? '距离最近' : '距离不限';
    },
    timeText() {
      return this.timeFilter === 'latest' ? '最新发布' : '最早发布';
    },
    salaryText() {
      return this.salaryFilter === 'unlimited' ? '酬金不限' : '酬金最高';
    },
    selectedLocation() {
      if (this.selectedRegion.district) {
        return `${this.selectedRegion.district}`;
      } else if (this.selectedRegion.city) {
        return `${this.selectedRegion.city}`;
      }
      return this.localAddress;
    }
  },
  // 分享给朋友
  onShareAppMessage() {
    
    return {
      title: '快来看看我发现的优质兼职！',
      path: '/pages/index-new/index',
      imageUrl: this.getFullImageUrl('/index/logo.jpg') // 替换为实际的分享封面图
    };
  },
  // 分享到朋友圈
  onShareTimeline() {
    return {
      title: '优质兼职信息，快来看看吧！',
      query: 'from=timeline',
      imageUrl: this.getFullImageUrl('/index/logo.jpg') // 替换为实际的分享封面图
    };
  },
  methods: {
    getFullImageUrl,

    // 接收来自map-page的位置更新
    updateLocation(data) {
      // 更新经纬度和地址
      this.latitude = Number(data.latitude) || 0;
      this.longitude = Number(data.longitude) || 0;
      this.localAddress = data.address || '';

      // 存储选中的地区信息
      const region = {
        city: data.address.split('市')[0] + '市',
        district: data.address.split('市')[1] || ''
      };
      this.selectedRegion = region;
      uni.setStorageSync('selectedRegion', region);

      // 重置分页参数
      this.pageParams.page = 1;
      this.hasMore = true;

      // 刷新订单数据
      this.fetchJobs();

      console.log('位置更新成功:', data.address);
    },
    navigateToOrderDetail() {
      // 检查是否登录
      if (!checkLogin()) {
        uni.navigateTo({
          url: '/pages/pageLogin/index'
        });
        return;
      }
      uni.navigateTo({
        url: '/pages/pageMy/orderCenter/orderCenter'
      });
    },
    navigateToChat() {
      // 检查是否登录
      if (!checkLogin()) {
        uni.navigateTo({
          url: '/pages/pageLogin/index'
        });
        return;
      }
      uni.switchTab({
        url: '/pages/chat/index'
      });
    },
    async navigateToEmergency() {
      // 检查是否登录
      if (!checkLogin()) {
        uni.navigateTo({
          url: '/pages/pageLogin/index'
        });
        return;
      }
      
      // 异步获取实名认证状态
      const isAuth = await this.fetchUserInfo();
      if (!isAuth) {
        // 显示实名认证弹窗
        this.$refs.authWinRef.openPopup();
        return;
      }
      uni.navigateTo({
        url: '/pages/release/position-select?type=4'
      });
    },

    // 检查实名认证状态并在未实名时弹出提示（登录后首次进入首页时弹出一次）
    async checkAuthStatus() {
      try {
        // 检查是否已经显示过实名认证弹窗
        const hasShownAuthPopup = uni.getStorageSync('hasShownAuthPopup');
        if (hasShownAuthPopup) {
          return; // 如果已经显示过，直接返回
        }

        const res = await request({
          url: '/User/info',
          method: 'GET'
        });

        if (res.code === 200 && res.data) {
          const userInfo = res.data;
          this.auth = userInfo.realname_verified === 1 ? true : false;
          
          // 如果未实名认证，显示实名认证弹窗
          if (!this.auth) {
            // 标记已经显示过弹窗
            uni.setStorageSync('hasShownAuthPopup', true);
            
            setTimeout(() => {
              this.$refs.authWinRef.openPopup();
            }, 500); // 延迟500ms显示，避免页面刚加载时的突兀感
          }
        }
      } catch (err) {
        console.error('获取用户信息错误:', err);
      }
    },

    // 获取用户信息并返回实名认证状态
    async fetchUserInfo() {
      try {
        const res = await request({
          url: '/User/info',
          method: 'GET'
        });

        if (res.code === 200 && res.data) {
          const userInfo = res.data;
          this.auth = userInfo.realname_verified === 1 ? true : false;
          return this.auth;
        }
        return false;
      } catch (err) {
        console.error('获取用户信息错误:', err);
        return false;
      }
    },

    // 关闭认证弹窗
    closeAuthWin() {
      // 可以在这里添加关闭弹窗后的逻辑
    },
    async navigateToAiDemand() {
      // 检查是否登录
      if (!checkLogin()) {
        uni.navigateTo({
          url: '/pages/pageLogin/index'
        });
        return;
      }
      
      // 异步获取实名认证状态
      const isAuth = await this.fetchUserInfo();
      if (!isAuth) {
        // 显示实名认证弹窗
        this.$refs.authWinRef.openPopup();
        return;
      }
      uni.navigateTo({
        url: '/pages/release/index'
      });
    },

    // 获取Banner数据
    fetchBanner() {
      request({
        url: '/Index/fetchBanner',
        method: 'GET'
      }).then(res => {
        console.log('获取Banner数据成功:', res.data);
        if (res.code === 1) {
          this.bannerData = res.data || [];
        } else {
          console.error('获取Banner数据失败:', res.msg);
        }
      }).catch(err => {
        console.error('获取Banner数据失败:', err);
      });
    },
    async getLocation() {
      try {
        // 1. 先检查是否有选中的地区
        if (this.selectedRegion && this.selectedRegion.city) {
          console.log('使用选中的地区获取经纬度:', this.selectedRegion);
          // 调用地理编码API，将地区转换为经纬度
          const geoInfo = await this.geocoder(this.selectedRegion.city, this.selectedRegion.district);
          if (geoInfo) {
            this.latitude = geoInfo.latitude;
            this.longitude = geoInfo.longitude;
            this.localAddress = `${this.selectedRegion.city}${this.selectedRegion.district ? this.selectedRegion.district : ''}`;
            this.hasLoadedLocation = true;
            console.log('通过地区获取经纬度成功:', this.latitude, this.longitude);
            return;
          }
        }

        // 2. 如果没有选中的地区或地理编码失败，尝试获取当前位置
        console.log('尝试获取当前位置经纬度');
        const res = await uni.getLocation({
          type: 'gcj02',
          altitude: true
        });

        this.latitude = res.latitude;
        this.longitude = res.longitude;

        // 3. 调用逆地理编码API获取详细地址
        const addressInfo = await this.reverseGeocoder(res.latitude, res.longitude);
        console.log('通过当前位置获取详细地址:', addressInfo.address);
        this.localAddress = addressInfo.address;
        this.hasLoadedLocation = true;
        
        // 4. 同步更新selectedRegion为当前定位信息
        const currentRegion = {
          city: addressInfo.address.split('市')[0] + '市',
          district: addressInfo.address.split('市')[1] || ''
        };
        this.selectedRegion = currentRegion;
        uni.setStorageSync('selectedRegion', currentRegion);

      } catch (err) {
        console.error('获取位置失败:', err);
        // 如果获取位置失败，使用默认经纬度
        this.latitude = 39.908823;
        this.longitude = 116.397470;
        this.localAddress = '北京市';
        this.hasLoadedLocation = true;
        console.log('使用默认经纬度:', this.latitude, this.longitude);
        uni.showToast({
          title: '无法获取位置，使用默认位置',
          icon: 'none'
        });
      }
    },

    // 地理编码方法 - 将地址转换为经纬度 - 调用后端API
    async geocoder(city, district) {
      return new Promise((resolve, reject) => {
        request({
          url: `txmap/geocoder`,
          method: 'GET',
          data: {
            city,
            district
          },
          success: (res) => {
            if (res.data.code === 1) {
              // 返回经纬度信息
              resolve({
                latitude: res.data.data.latitude,
                longitude: res.data.data.longitude
              });
            } else {
              console.error('地理编码失败:', res.data.msg);
              resolve(null);
            }
          },
          fail: (err) => {
            console.error('地理编码请求失败:', err);
            resolve(null);
          }
        });
      });
    },

    // 逆地理编码方法 - 使用统一的mapUtils
    async reverseGeocoder(latitude, longitude) {
          try {
            // 使用后端API方式
            const result = await reverseGeocoder(latitude, longitude, true);
            return result;
          } catch (error) {
            console.error('逆地理编码失败:', error);
            throw error;
          }
        },

    // 导航到切换城市页面
    navigateToSelectedCity() {
      uni.navigateTo({
        url: '/pages/Receiveorders/selectedCity/selectedCity?fromPage=index-new', // 传递来源页面参数
        success: () => {
          console.log('跳转切换城市页面成功');
        },
        fail: (err) => {
          console.error('跳转切换城市页面失败:', err);
        }
      });
    },
    toggleMenu(menu) {
      if (this.activeMenu === menu) {
        this.activeMenu = '';
      } else {
        this.activeMenu = menu;
      }
    },
    // 这些方法已在下方完整实现，此处不再重复定义
    handleApply(job) {
      if (job.isApplied) return;

      // 检查是否登录
      if (!checkLogin()) {
        uni.navigateTo({
          url: '/pages/pageLogin/index'
        });
        return;
      }

      // 调用报名接口
      request({
        url: 'Taskapply/apply_task',
        method: 'POST',
        data: {
          task_id: job.id
        },
        success: (res) => {
          if (res.data.code === 200) {
            this.showApplySuccess = true;
            // 更新任务状态为已报名
            job.isApplied = true;
            setTimeout(() => {
              this.showApplySuccess = false;
            }, 2000);
          } else {
            uni.showToast({
              title: res.data.msg || '报名失败',
              icon: 'none'
            });
          }
        },
        fail: () => {
          uni.showToast({
            title: '网络错误，请稍后重试',
            icon: 'none'
          });
        }
      });
    },
    
    // 处理订单成功事件
    handleOrderSuccess(orderData) {
      this.successOrderData = orderData;
      this.showSuccessModal = true;
      
      // 刷新订单列表
      this.pageParams.page = 1;
      this.hasMore = true;
      this.fetchJobs();
    },
    
    // 关闭订单成功弹窗
    closeSuccessModal() {
      this.showSuccessModal = false;
      this.successOrderData = {};
    },
    
    // 处理WebSocket消息
    handleWebSocketMessage(message) {
      try {
        console.log('首页收到WebSocket消息:', message);
        // 如果消息已经是对象类型，直接使用
        const parsedMessage = typeof message === 'string' ? JSON.parse(message) : message;
        console.log('解析后的消息:', parsedMessage);

        // 检查是否是订单成功的消息
        if (parsedMessage.type === 'order_success' || parsedMessage.type === 'candidate_selected') {
          console.log('收到订单成功消息:', parsedMessage);
          // 处理订单成功事件
          this.handleOrderSuccess(parsedMessage.data || {});
        }
      } catch (error) {
        console.error('处理WebSocket消息时出错:', error);
      }
    },
    handleFilterChange() {
      this.pageParams.page = 1; // 重置页码
      this.fetchJobs(); // 重新获取数据
    },
    selectCategory(categoryId) {
      this.selectedCategory = categoryId;
      this.activeMenu = '';
      this.pageParams.page = 1;
      this.hasMore = true;
      this.fetchJobs();
    },
    // 综合筛选方法
    selectFilter(type, value) {
      // 更新当前选中的筛选类型和值
      this.currentFilter = { type, value };
      
      // 立即关闭菜单
      this.activeMenu = '';
      
      // 强制DOM更新后再执行数据刷新
      this.pageParams.page = 1;
      this.hasMore = true;
      this.fetchJobs();
    },
    
    // 获取当前选中筛选项的显示文字
    getFilterText() {
      const { type, value } = this.currentFilter;
      if (type === 'time') {
        return value === 'latest' ? '最新发布' : '最早发布';
      } else if (type === 'distance') {
        return value === 'nearest' ? '距离最近' : '距离不限';
      } else if (type === 'salary') {
        return value === 'highest' ? '酬金最高' : '酬金不限';
      }
      return '筛选';
    },

    fetchCategories() {
      this.isLoading = true;
      request({
        url: '/Category/list?parent_id=0', // 带查询参数的POST请求
        method: 'POST'
      }).then(res => {
        // 检查接口返回状态
        if (res.code === 200) {
          // 存储后端返回的分类数据
          this.categories = res.data.list;
          console.log(this.categories);

          // 默认选中第一个分类，如果没有分类则不选中
          if (this.categories && this.categories.length > 0) {
            this.selectedCategory = this.categories[0].id;
          } else {
            this.selectedCategory = null;
          }
        } else {
          uni.showToast({ title: res.msg || '获取分类失败', icon: 'none' });
          // 加载失败时显示默认分类
          this.categories = [];
          this.selectedCategory = null;
        }
      }).catch(err => {
        console.error('获取分类失败:', err);
        uni.showToast({ title: '网络错误，无法加载分类', icon: 'none' });
        this.categories = [];
        this.selectedCategory = null;
      }).finally(() => {
        this.isLoading = false;
      });
    },

    // 获取订单数据
    fetchJobs() {
      // 如果正在加载或没有更多数据，不执行请求
      if (this.isLoading || !this.hasMore) return;

      this.isLoading = true;
      // 合并分页参数和筛选参数（使用单一筛选参数）
      const params = {
        page: this.pageParams.page,
        limit: this.pageParams.limit,
        filter: this.currentFilter,
        category_name: 0,
        lat: this.latitude,
        lng: this.longitude,
      };

      console.log('传递给workerList的经纬度参数:', this.latitude, this.longitude);

      request({
        url: '/Takeorders/workerList',
        method: 'POST',
        data: params
      }).then(res => {
        console.log('workerList接口返回数据:', res);
        const newJobs = res.data || [];
        // 第一页直接替换数据，后续页追加数据
        if (this.pageParams.page === 1) {
          this.jobs = newJobs;
        } else {
          this.jobs = this.jobs.concat(newJobs);
        }
        // 判断是否还有更多数据
        this.hasMore = newJobs.length === this.pageParams.limit;
      }).catch(err => {
        console.error('获取订单数据失败', err);
        uni.showToast({
          title: '获取订单数据失败，请重试',
          icon: 'none'
        });
      }).finally(() => {
        this.isLoading = false;
      });
    },

    onReachBottom() {
      // 触底时加载下一页
      if (this.hasMore && !this.isLoading) {
        console.log('触底了');
        this.pageParams.page++;
        console.log('当前页码', this.pageParams.page);
        this.fetchJobs();
      }
    },
    getCategoryName(categoryId) {
      if (!categoryId) return '分类';
      const category = this.categories.find(c => c.id === categoryId);
      return category ? category.name : '分类';
    }
  }};
